/**
 * @description 函数防抖，闭包版
 */
export function debounce(func, wait, immediate) {
    let timeout, args, context, timestamp, result

    const later = function() {
        // 据上一次触发时间间隔
        const last = +new Date() - timestamp

        // 上次被包装函数被调用时间间隔last小于设定时间间隔wait
        if (last < wait && last > 0) {
            timeout = setTimeout(later, wait - last)
        } else {
            timeout = null
            // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
            if (!immediate) {
                result = func.apply(context, args)
                if (!timeout) context = args = null
            }
        }
    }

    return function(...args) {
        context = this
        timestamp = +new Date()
        const callNow = immediate && !timeout
        // 如果延时不存在，重新设定延时
        if (!timeout) timeout = setTimeout(later, wait)
        if (callNow) {
            result = func.apply(context, args)
            context = args = null
        }

        return result
    }
}

const DEBOUNCE = { // 防抖函数任务控制
    task: null
};
/**
 * 函数防抖
 * @param func 执行的任务
 * @param wait 等待时间
 * @param options 函数参数
 */
export function debounceNotClosure (func, wait, ...options) {
    if (typeof func !== 'function') {
        throw new Error('【参数类型错误】func参数只能接受function类型');
    }
    wait = +wait;
    if (isNaN(wait)) {
        throw new Error('【参数类型错误】wait只能是number，或者能被转换成number的字符串');
    }
    if (DEBOUNCE.task) {
        clearTimeout(DEBOUNCE.task);
        DEBOUNCE.task = null;
    } else {
        DEBOUNCE.task = setTimeout(function () {
            func.call(this, ...options);
        }.bind(this), wait);
    }
}

const THROTTLE_TIME = { // 防抖函数时间控制
    lastTime: 0
};
/**
 * 函数节流
 * @param func 执行的任务
 * @param delay 延迟时间
 * @param options 函数参数
 */
export function throttle (func, delay, ...options) {
    if (typeof func !== 'function') {
        throw new Error('【参数类型错误】func参数只能接受function类型');
    }
    delay = +delay;
    if (isNaN(delay)) {
        throw new Error('【参数类型错误】wait只能是number，或者能被转换成number的字符串');
    }
    const now = Date.now();
    const diff = now - THROTTLE_TIME.lastTime;
    if (diff < delay) return;
    func.call(this, ...options);
    THROTTLE_TIME.lastTime = now;
}